// 网络状态管理模块

/**
 * 初始化网络状态检测
 */
export function initNetworkStatus() {
  // 初始检查
  updateNetworkStatus();

  // 监听网络状态变化事件
  window.addEventListener('online', updateNetworkStatus);
  window.addEventListener('offline', updateNetworkStatus);
}

/**
 * 更新网络状态显示
 */
export function updateNetworkStatus() {
  const statusBar = document.getElementById('statusBar');
  if (!statusBar) return;

  if (navigator.onLine) {
    statusBar.textContent = '在线 - 可获取最新内容';
    statusBar.className = 'status-bar online';
  } else {
    statusBar.textContent = '离线 - 使用缓存内容';
    statusBar.className = 'status-bar offline';
  }
}

/**
 * 检查网络连接状态
 * @returns {boolean} 当前是否在线
 */
export function isOnline() {
  return navigator.onLine;
}

/**
 * 检查网络连接状态
 * @returns {Promise<boolean>} 网络是否连接
 */
export function checkNetworkStatus() {
  // 使用navigator.onLine API检查基本网络连接状态
  // 这是一个更轻量级的方法，不需要发送实际的HTTP请求
  return Promise.resolve(navigator.onLine);
}

/**
 * 定期检查网络连接状态
 * @param {number} interval - 检查间隔（毫秒）
 * @param {function(boolean)} callback - 状态变化回调函数
 * @param {Object} options - 配置选项
 * @returns {number} 定时器ID，用于清除
 */
export function setupPeriodicNetworkCheck(interval = 30000, callback, options = {}) {
  const { enableStabilityCheck = false } = options;
  let lastStatus = null;

  function performCheck() {
    let checkPromise = Promise.resolve(navigator.onLine);
    
    // 仅在启用稳定性检查时执行网络稳定性请求
    if (enableStabilityCheck) {
      checkPromise = networkStatusMonitor.checkNetworkStability().then(isStable => isStable && navigator.onLine);
    }
    
    checkPromise.then(isConnected => {
      // 只有状态变化时才调用回调
      if (lastStatus !== isConnected && callback) {
        callback(isConnected);
        lastStatus = isConnected;
      }
    });
  }

  // 立即执行一次检查
  performCheck();

  // 设置定期检查
  const timerId = setInterval(performCheck, interval);
  
  console.log(`已设置定期网络检查，间隔 ${interval}ms${enableStabilityCheck ? ' (包含稳定性检查)' : ''}`);
  return timerId;
}

// 保持向后兼容性
export function setupPeriodicServerCheck(interval = 5000, callback) {
  console.warn('setupPeriodicServerCheck is deprecated. Use setupPeriodicNetworkCheck instead.');
  return setupPeriodicNetworkCheck(interval, callback);
}

/**
 * 网络状态监控类 - 提供高级网络状态监控功能
 */
export class NetworkStatusMonitor {
  constructor() {
    this.isOnline = navigator.onLine;
    this.listeners = new Map();
    this.notificationOptions = {
      online: {
        title: '已连接到网络',
        body: '应用现在可以正常访问网络资源',
        icon: '/icons/icon-192x192.png',
        badge: '/icons/badge-192x192.png',
        tag: 'network-status',
        vibrate: [100, 50, 100]
      },
      offline: {
        title: '网络连接已断开',
        body: '应用已切换到离线模式，部分功能可能受限',
        icon: '/icons/icon-192x192.png',
        badge: '/icons/badge-192x192.png',
        tag: 'network-status',
        vibrate: [300, 200, 300]
      }
    };
    this.isNotificationEnabled = false;
    this.init();
  }

  /**
   * 初始化网络状态监控
   */
  init() {
    this.setupEventListeners();
    this.checkNotificationPermission();
  }

  /**
   * 设置事件监听器
   */
  setupEventListeners() {
    window.addEventListener('online', this.handleOnline.bind(this));
    window.addEventListener('offline', this.handleOffline.bind(this));
  }

  /**
   * 处理网络连接恢复事件
   */
  handleOnline() {
    this.isOnline = true;
    console.log('网络已连接');
    this.notifyStatusChange('online');
    this.triggerCallbacks('online');
  }

  /**
   * 处理网络连接断开事件
   */
  handleOffline() {
    this.isOnline = false;
    console.log('网络已断开');
    this.notifyStatusChange('offline');
    this.triggerCallbacks('offline');
  }

  /**
   * 检查通知权限
   */
  async checkNotificationPermission() {
    if (!('Notification' in window)) {
      console.warn('浏览器不支持桌面通知');
      return;
    }

    if (Notification.permission === 'granted') {
      this.isNotificationEnabled = true;
    } else if (Notification.permission !== 'denied') {
      const permission = await Notification.requestPermission();
      this.isNotificationEnabled = permission === 'granted';
    }
  }

  /**
   * 发送网络状态变化通知
   */
  notifyStatusChange(status) {
    if (!this.isNotificationEnabled || !('Notification' in window)) {
      return;
    }

    try {
      const notification = new Notification(
        this.notificationOptions[status].title,
        this.notificationOptions[status]
      );

      // 3秒后自动关闭通知
      setTimeout(() => notification.close(), 3000);
    } catch (error) {
      console.error('发送网络状态通知失败:', error);
    }
  }

  /**
   * 添加状态变化监听器
   */
  addListener(callback, id = Math.random().toString(36).substr(2, 9)) {
    if (typeof callback !== 'function') {
      throw new Error('回调必须是一个函数');
    }

    this.listeners.set(id, callback);
    
    // 立即使用当前状态调用回调
    callback(this.isOnline ? 'online' : 'offline');
    
    return id;
  }

  /**
   * 移除状态变化监听器
   */
  removeListener(id) {
    return this.listeners.delete(id);
  }

  /**
   * 触发所有回调函数
   */
  triggerCallbacks(status) {
    this.listeners.forEach(callback => {
      try {
        callback(status);
      } catch (error) {
        console.error('执行网络状态回调时出错:', error);
      }
    });
  }

  /**
   * 获取当前网络状态
   */
  getStatus() {
    return this.isOnline ? 'online' : 'offline';
  }

  /**
   * 检查网络连接是否稳定
   * @returns {Promise<boolean>} 网络是否稳定
   */
  async checkNetworkStability() {
    try {
      // 使用fetch请求一个小的资源来测试网络稳定性
      const response = await fetch('/favicon.ico', {
        method: 'HEAD',
        cache: 'no-cache',
        signal: AbortSignal.timeout(5000) // 5秒超时
      });
      
      return response.ok;
    } catch (error) {
      console.warn('网络稳定性测试失败:', error);
      return false;
    }
  }

  /**
   * 获取详细的网络信息
   * @returns {Promise<Object>} 网络信息对象
   */
  async getNetworkInfo() {
    const info = {
      isOnline: this.isOnline,
      timestamp: new Date().toISOString(),
      supported: true
    };

    // 检查是否支持Navigator.connection API
    if ('connection' in navigator) {
      const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
      
      info.type = connection.type || 'unknown';
      info.effectiveType = connection.effectiveType || 'unknown';
      info.downlink = connection.downlink || null; // Mbps
      info.rtt = connection.rtt || null; // ms
      info.saveData = connection.saveData || false;
    } else {
      info.supported = false;
      console.warn('浏览器不支持详细的网络信息API');
    }

    // 添加网络稳定性检查结果
    info.stable = await this.checkNetworkStability();

    return info;
  }

  /**
   * 请求显示网络状态通知的权限
   */
  async requestNotificationPermission() {
    if (!('Notification' in window)) {
      throw new Error('浏览器不支持桌面通知');
    }

    const permission = await Notification.requestPermission();
    this.isNotificationEnabled = permission === 'granted';
    return this.isNotificationEnabled;
  }

  /**
   * 清理资源
   */
  cleanup() {
    window.removeEventListener('online', this.handleOnline);
    window.removeEventListener('offline', this.handleOffline);
    this.listeners.clear();
  }
}

// 创建单例实例
export const networkStatusMonitor = new NetworkStatusMonitor();
